What

Adds one associated const and fn each to Absorb, as well the new Type TryCompressResult returned by that fn. Together they allow WriteHandle::extend (and by extension WriteHandle::append) to optimize the op-log by combining certain operations into one.

Why

Reading/Watching about left-right/evmap it was mentioned that on top of the base doubling (unless carefully deduplicated) of memory the op-log can get quite out of hand if only infrequently published. That got me thinking about how, in a toy example of a simple map, you could combine set-ops with the same key to be the last one, merge certain modify-ops (like add), and completely consume the op-log when emitting a clear-op. Then I looked at the source and found it quite straightforward to implement. So I did (in about six hours).

How

When compression is enabled WriteHandle::extend reverse-walks the fully unpublished portion of the op-log while attempting to combine ops. It does this by calling Absorb::try_compress and either:

• skipping an empty entry
• leaving behind an empty entry and continuing on when it returned TryCompressResult::Compressed
• skipping an entry and continuing on when it returned TryCompressResult::Independent
• stopping and inserting the op when it returned TryCompressResult::Dependent

After finishing for all ops it then stably moves all empty entries to the end of the op-log before truncating it.

I have also added three (edit: four) complementary optimizations to avoid some pathological worst cases:

• It keeps track of the first non-empty entry from the back to avoid fully iterating a long but empty op-log in the case of a 'clear' (which consumes everything) being followed by a 'set'
• edit: It keeps track of the last non-empty entry from the front to avoid fully iterating a full op-log in the case of all the empty entries being only found towards the back.
• It keeps track of its most recently encountered empty entry to avoid unnecessarily growing the op-log when inserting.
• It stops after getting Absorb::MAX_COMPRESS_RANGE TryCompressResult::Independents in a row to avoid iterating the full op-log in case it is filled with predominantly independent ops.

Caveats

• Even though they are only temporarily empty during WriteHandle::extend, the op-log now contains options instead of values. As ops are basically always enums, enum folding and opt.unwrap_or_else(|| unreachable!()) should(?) remove any overhead.
• Probably needs more tests than the ones I have already added. (edit: everything should now be covered)
• Lots of slow but thorough debug_assert!(...)s, which should leave no traces in a release build.

Is it useful?

Frankly, I don't know. I haven't actually used left-right in any serious projects and so can't really judge if this optimization is worthwhile. However, because compression is controlled via an associated const, it should monomorphize away and so at least not degrade performance when disabled, otherwise, it basically shifts writer-side computation from publishing to extending while potentially saving a fair chunk of memory. (Though come to think of it, it should also be quite straightforward to move the compression into WriteHandle::publish, though it then wouldn't be saving any memory, which likely is the main benefit.)

This change is